import Mock from 'mockjs'

/**
 * 部门树数据
 * 结构包含以下字段：
 * - id: 部门ID
 * - parentId: 父部门ID
 * - name: 部门名称
 * - children: 子部门列表
 */
const deptTreeData = [
    {
        id: '065a3eb180214ccfbb653f63287d285d',
        parentId: '',
        parentName: '',
        name: 'NB PLUS 科技',
        createBy: 'admin',
        createTime: '2023-06-01 10:00:00',
        updateby: 'admin',
        updateTime: '2023-06-01 10:00:00',
        seqNo: 0,
        status: 1,
        children: [
            {
                id: '6bcbfa6a71fa454d8363b885ccbcb30a',
                parentId: '065a3eb180214ccfbb653f63287d285d',
                parentName: 'NB PLUS 科技',
                name: 'XXX总公司',
                createBy: 'admin',
                createTime: '2023-06-01 10:00:00',
                updateby: 'admin',
                updateTime: '2023-06-01 10:00:00',
                seqNo: 0,
                status: 1,
                children: [
                    {
                        id: '88921a7b70a04ea2b7d1db1651ffe666',
                        parentId: '6bcbfa6a71fa454d8363b885ccbcb30a',
                        parentName: 'XXX总公司',
                        name: '研发部',
                        createBy: 'admin',
                        createTime: '2023-06-01 10:00:00',
                        updateby: 'admin',
                        updateTime: '2023-06-01 10:00:00',
                        seqNo: 0,
                        status: 1,
                        children: []
                    },
                    {
                        id: '3fd2fbc8c93e4a20a6e46387b36c0264',
                        parentId: '6bcbfa6a71fa454d8363b885ccbcb30a',
                        parentName: 'XXX总公司',
                        name: '销售部',
                        createBy: 'admin',
                        createTime: '2023-06-01 10:00:00',
                        updateby: 'admin',
                        updateTime: '2023-06-01 10:00:00',
                        seqNo: 1,
                        status: 1,
                        children: []
                    }
                ]
            }
        ]
    }
]

// 扁平化的部门列表，用于列表查询
const deptList = flattenTree(deptTreeData[0])

export default [
    // 获取部门树接口
    {
        url: '/dev-api/system/block/dept/getDeptTree',
        method: 'get',
        response: () => {
            return {
                code: 1,
                message: '操作成功',
                data: deptTreeData
            }
        }
    },

    // 查询部门列表接口
    {
        url: '/dev-api/system/block/dept/list',
        method: 'get',
        response: ({ query }) => {
            // 解析查询参数
            const name = query.name // 部门名称筛选
            const status = query.status // 部门状态筛选

            // 初始数据为完整部门列表
            let filteredData = [...deptList]

            // 按部门名称筛选
            if (name) {
                filteredData = filteredData.filter((item) => item.name.includes(name))
            }

            // 按状态筛选
            if (status) {
                filteredData = filteredData.filter((item) => item.status == status)
            }

            return {
                code: 1,
                message: '操作成功',
                data: filteredData
            }
        }
    },

    // 新增部门接口
    {
        url: '/dev-api/system/block/dept/addDept',
        method: 'post',
        response: ({ body }) => {
            const newDept = body
            // 生成新部门ID
            newDept.id = Mock.Random.guid()
            // 初始化子部门列表
            newDept.children = []

            // 如果有父部门ID，则添加到对应父部门下
            if (newDept.parentId) {
                const parent = findDepartment(deptTreeData, newDept.parentId)
                if (parent) {
                    parent.children.push(newDept)
                }
            } else {
                // 否则作为顶级部门添加
                deptTreeData.push(newDept)
            }

            // 更新扁平化列表
            deptList.push({
                id: newDept.id,
                parentId: newDept.parentId,
                name: newDept.name,
                status: newDept.status || 1,
                createTime: Mock.Random.now()
            })

            return {
                code: 1,
                message: '新增成功'
            }
        }
    },

    // 编辑部门接口
    {
        url: '/dev-api/system/block/dept/editDept',
        method: 'put',
        response: ({ body }) => {
            const updatedDept = body
            // 查找要更新的部门
            const dept = findDepartment(deptTreeData, updatedDept.id)

            if (dept) {
                // 更新部门信息
                dept.name = updatedDept.name
                // 这里可以更新其他字段...

                // 同时更新扁平化列表中的数据
                const flatDept = deptList.find((item) => item.id === updatedDept.id)
                if (flatDept) {
                    flatDept.name = updatedDept.name
                    // 更新其他字段...
                }
            }

            return {
                code: 1,
                message: '修改成功'
            }
        }
    },

    // 修改部门状态接口
    {
        url: '/dev-api/system/block/dept/editDeptStatus',
        method: 'put',
        response: ({ body }) => {
            const { id, status } = body
            // 查找要更新的部门
            const dept = findDepartment(deptTreeData, id)

            if (dept) {
                // 更新状态
                dept.status = status

                // 同时更新扁平化列表中的状态
                const flatDept = deptList.find((item) => item.id === id)
                if (flatDept) {
                    flatDept.status = status
                }
            }

            return {
                code: 1,
                message: '状态修改成功'
            }
        }
    },

    // 删除部门接口
    {
        url: '/dev-api/system/block/dept/deleteDept/:id',
        method: 'delete',
        response: ({ query }) => {
            const deptId = query.id

            // 从树结构中删除该部门
            removeDepartment(deptTreeData, deptId)

            // 从扁平化列表中删除该部门
            const index = deptList.findIndex((item) => item.id === deptId)
            if (index !== -1) {
                deptList.splice(index, 1)
            }

            return {
                code: 1,
                message: '删除成功'
            }
        }
    }
]

/**
 * 将树形结构扁平化为列表
 * @param {Object} node - 当前节点
 * @returns {Array} 扁平化的部门列表
 */
function flattenTree(node) {
    const result = [
        {
            id: node.id,
            parentId: node.parentId,
            parentName: node.parentName,
            name: node.name,
            createBy: node.createBy,
            createTime: node.createTime || Mock.Random.now(),
            updateby: node.updateby,
            updateTime: node.updateTime,
            seqNo: node.seqNo,
            status: node.status || 1,
            statusDesc: node.status == 1 ? '启用' : '禁用'
        }
    ]

    // 递归处理子节点
    node.children.forEach((child) => {
        result.push(...flattenTree(child))
    })

    return result
}

/**
 * 在部门树中查找指定部门
 * @param {Array} nodes - 部门节点列表
 * @param {String} id - 要查找的部门ID
 * @returns {Object|null} 找到的部门对象，未找到返回null
 */
function findDepartment(nodes, id) {
    for (const node of nodes) {
        if (node.id === id) return node
        if (node.children) {
            const found = findDepartment(node.children, id)
            if (found) return found
        }
    }
    return null
}

/**
 * 从部门树中删除指定部门
 * @param {Array} nodes - 部门节点列表
 * @param {String} id - 要删除的部门ID
 * @returns {Boolean} 是否删除成功
 */
function removeDepartment(nodes, id) {
    for (let i = 0; i < nodes.length; i++) {
        if (nodes[i].id === id) {
            nodes.splice(i, 1)
            return true
        }
        if (nodes[i].children && removeDepartment(nodes[i].children, id)) {
            return true
        }
    }
    return false
}
